ALMaSS  1.0
The Animal, Landscape and Man Simulation System
Hunter_Population_Manager Class Reference

The class to handle all predator population related matters. More...

#include <Hunters_all.h>

Inheritance diagram for Hunter_Population_Manager:
Population_Manager

Public Member Functions

 Hunter_Population_Manager (Landscape *p_L)
 Hunter population manager constructor. More...
 
virtual ~Hunter_Population_Manager (void)
 Hunter population manager destructor. More...
 
void Init (void)
 Create the initial hunter population and initializes any output options. More...
 
void DistributeHunters (void)
 Distributes hunters to hunting locations (farms). More...
 
void DistributeHuntersByRules (vector< HunterInfo > *a_hunterlist, int a_no_hunters, int a_ruleset)
 Implements the rule sets to distributes hunters to hunting locations (farms). More...
 
void RuleSet10Based (int a_no_hunters, vector< int > *a_farmsizes, vector< HunterInfo > *a_hunterlist, vector< APoint > *a_roostlocs, int a_ruleset)
 Used to implement rule sets based on rule set 10. More...
 
void SaveDistributedHunters (vector< HunterInfo > *a_hunterlist, int a_no_hunters)
 Saves the results of the hunter distribution to an output file. More...
 
void SaveFarmHunters (vector< HunterInfo > *a_hunterlist, int a_no_hunters)
 Saves the results of the hunter distribution to an output file by farm. More...
 
void CreateObjects (int ob_type, TAnimal *, struct_Hunter *data, int number)
 Creates hunter objects and assigns them to the population manager lists. More...
 
void RecordHuntingSuccess (int poly, int birds, int a_hunter)
 Hunting bag output. More...
 
APoint GetHunterHome (int a_index, int a_list)
 Returns the hunter home location. More...
 
APoint GetHunterHuntLoc (int a_index, int a_list, unsigned a_ref)
 Returns the hunter hunting location location. More...
 
unsigned GetNoHuntLocs ()
 Calculates the number of hunting locations based on a distribution. More...
 
bool CheckDensity (int a_ref, vector< int > *a_illegalfarms, vector< FarmOccupcancyData > *a_FarmOccupancy)
 helper method to reduce code size in hunter rules - checks density rules More...
 
bool AddHunterHunting (int a_polyref, Hunter *a_hunter)
 Adds a hunter hunting, returns true if that hunter is the leader otherwise false. More...
 
void HunterLeaderMessage (TypeOfHunterLeaderMessage a_signal, int a_polyref)
 A message system to rely messages from the leader hunter to others in his team. More...
 
bool IsPolyrefOnActiveList (int a_polyref)
 Debugging check method. More...
 
void SetHuntingSeason ()
 This returns the number of geese which are legal quarry on the polygon the day before. More...
 
int GetHuntingSeasonStart ()
 Get the start of the overall hunting season. More...
 
int GetHuntingSeasonEnd ()
 Get the end of the overall hunting season. More...
 
- Public Member Functions inherited from Population_Manager
 Population_Manager (Landscape *L)
 
virtual ~Population_Manager (void)
 
void SetNoProbes (int a_pn)
 
unsigned GetLiveArraySize (int a_listindex)
 Gets the number of 'live' objects for a list index in the TheArray. More...
 
void IncLiveArraySize (int a_listindex)
 Increments the number of 'live' objects for a list index in the TheArray. More...
 
virtual void Catastrophe (int)
 
unsigned int FarmAnimalCensus (unsigned int a_farm, unsigned int a_typeofanimal)
 
char * SpeciesSpecificReporting (int a_species, int a_time)
 
char * ProbeReport (int a_time)
 
char * ProbeReportTimed (int a_time)
 
void ImpactProbeReport (int a_Time)
 
bool BeginningOfMonth ()
 
void LOG (const char *fname)
 
int SupplyStepSize ()
 
int SupplySimW ()
 
int SupplySimH ()
 
virtual void Run (int NoTSteps)
 
virtual float Probe (int ListIndex, probe_data *p_TheProbe)
 
virtual void ImpactedProbe ()
 
int SupplyListNameLength ()
 
TAnimalSupplyAnimalPtr (int a_index, int a_animal)
 Returns the pointer indexed by a_index and a_animal. Note NO RANGE CHECK. More...
 
unsigned SupplyListIndexSize ()
 
unsigned SupplyListSize (unsigned listindex)
 
bool CheckXY (int l, int i)
 Debug method to test for out of bounds coordinates. More...
 
const char * SupplyListName (int i)
 
bool IsLast (unsigned listindex)
 
int SupplyState (unsigned listindex, unsigned j)
 
virtual void SupplyLocXY (unsigned listindex, unsigned j, int &x, int &y)
 
const char * SupplyStateNames (int i)
 
unsigned SupplyStateNamesLength ()
 
virtual void DisplayLocations ()
 
int ProbeFileInput (char *p_Filename, int p_ProbeNo)
 
TAnimalFindClosest (int x, int y, unsigned Type)
 
bool OpenTheRipleysOutputProbe (string a_NWordFilename)
 
void OpenTheAOROutputProbe (string a_AORFilename)
 
bool OpenTheMonthlyRipleysOutputProbe ()
 
bool OpenTheReallyBigProbe ()
 
virtual void TheAOROutputProbe ()
 
virtual void TheRipleysOutputProbe (FILE *a_prb)
 
virtual void TheReallyBigOutputProbe ()
 
void CloseTheMonthlyRipleysOutputProbe ()
 
virtual void CloseTheRipleysOutputProbe ()
 
virtual void CloseTheReallyBigOutputProbe ()
 
TTypesOfPopulation GetPopulationType ()
 
int GetSeasonNumber ()
 Get the season number. More...
 
void LamdaDeath (int x, int y)
 
void LamdaBirth (int x, int y)
 
void LamdaBirth (int x, int y, int z)
 
void LamdaClear ()
 
void LamdaDumpOutput ()
 
virtual int SupplyPegPosx (int)
 
virtual int SupplyPegPosy (int)
 
virtual int SupplyCovPosx (int)
 
virtual int SupplyCovPosy (int)
 
virtual bool OpenTheFledgelingProbe ()
 
virtual bool OpenTheBreedingPairsProbe ()
 
virtual bool OpenTheBreedingSuccessProbe ()
 
virtual void BreedingPairsOutput (int)
 
virtual int TheBreedingFemalesProbe (int)
 
virtual int TheFledgelingProbe ()
 
virtual void BreedingSuccessProbeOutput (double, int, int, int, int, int, int, int)
 
virtual int TheBreedingSuccessProbe (int &, int &, int &, int &, int &, int &)
 
virtual void FledgelingProbeOutput (int, int)
 
virtual void TheGeneticProbe (unsigned, int, unsigned &)
 
virtual void GeneticsResultsOutput (FILE *, unsigned)
 

Public Attributes

vector< HunterList * > m_ActiveHuntingLocationsHunters
 Lists of hunters at all active hunting locations (updated daily) More...
 
vector< int > m_ActiveHuntingLocationsPolyrefs
 Lists of polygon reference numbers for all active hunting locations (updated daily) More...
 
- Public Attributes inherited from Population_Manager
int IndexArrayX [5][10000]
 
probe_dataTheProbe [100]
 
int SimH
 
int SimW
 
unsigned SimHH
 
unsigned SimWH
 
char m_SimulationName [255]
 
bool ProbesSet
 
Landscapem_TheLandscape
 

Protected Member Functions

virtual bool StepFinished ()
 Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour. More...
 
virtual void DoFirst ()
 Does general daily tasks e.g. reset time of day, reset bag lists if start of year etc.. More...
 
virtual void DoBefore ()
 Available for hunter management - not used currently. More...
 
virtual void DoAfter ()
 Available for hunter management - not used currently. More...
 
virtual void DoLast ()
 Available for hunter management - not used currently. More...
 
- Protected Member Functions inherited from Population_Manager
virtual void DoAlmostLast ()
 
void EmptyTheArray ()
 Removes all objects from the TheArray by deleting them and clearing TheArray. More...
 
void SortX (unsigned Type)
 
void SortXIndex (unsigned Type)
 
void SortY (unsigned Type)
 
void SortState (unsigned Type)
 
void SortStateR (unsigned Type)
 
unsigned PartitionLiveDead (unsigned Type)
 
void Shuffle_or_Sort (unsigned Type)
 
void Shuffle (unsigned Type)
 
virtual void Catastrophe ()
 

Protected Attributes

unsigned m_daytime
 Used to follow the time of day in 10 minute steps. More...
 
ofstream * m_HuntingBagRecord
 Output file for hunting bag record. More...
 
int m_HuntingSeasonStart
 Start of the overall hunting season. More...
 
int m_HuntingSeasonEnd
 End of the overall hunting season. More...
 
- Protected Attributes inherited from Population_Manager
vector< unsigned > m_LiveArraySize
 
int m_NoProbes
 
AOR_Probem_AOR_Probe
 
FILE * m_GeneticsFile
 
FILE * m_AlleleFreqsFile
 
FILE * m_EasyPopRes
 
const char * StateNames [100]
 
int m_catastrophestartyear
 
int m_StepSize
 
vector< TListOfAnimalsTheArray
 
unsigned StateNamesLength
 
const char * m_ListNames [32]
 
unsigned m_ListNameLength
 
FILE * TestFile
 
FILE * TestFile2
 
unsigned BeforeStepActions [12]
 
int m_SeasonNumber
 Holds the season number. Used when running goose and hunter sims. More...
 
TTypesOfPopulation m_population_type
 
ofstream * AOROutputPrb
 
FILE * RipleysOutputPrb
 
FILE * RipleysOutputPrb1
 
FILE * RipleysOutputPrb2
 
FILE * RipleysOutputPrb3
 
FILE * RipleysOutputPrb4
 
FILE * RipleysOutputPrb5
 
FILE * RipleysOutputPrb6
 
FILE * RipleysOutputPrb7
 
FILE * RipleysOutputPrb8
 
FILE * RipleysOutputPrb9
 
FILE * RipleysOutputPrb10
 
FILE * RipleysOutputPrb11
 
FILE * RipleysOutputPrb12
 
FILE * ReallyBigOutputPrb
 
long int lamdagrid [2][257][257]
 

Detailed Description

The class to handle all predator population related matters.

Constructor & Destructor Documentation

◆ Hunter_Population_Manager()

Hunter_Population_Manager::Hunter_Population_Manager ( Landscape p_L)

Hunter population manager constructor.

There are two possibilities here - we can be in simulation mode or distribution mode. Simulation mode calls Init and runs hunters as normal whereas distribution mode will attempt to distribute hunters to hunting locations based on model rules. This is also needed for the first time simulations are run to distribute the hunters and produce input for Hunter_Initiation.txt

119  : Population_Manager(p_L)
120 {
121  // Load List of Animal Classes
122  m_ListNames[0] = "Goose Hunter";
123  m_ListNameLength = 1;
124  // We need one vector for each life stage
125  for (unsigned i=0; i<(10-m_ListNameLength); i++)
126  {
127  TheArray.pop_back();
128  }
129  BeforeStepActions[ 0 ] = 4; // 0 = Shuffle, 1 = SortX, 2 = SortY, 3=SortXIndex, 4 = do nothing, 5 = shuffle 1 in 500 times
137  m_HuntingSeasonEnd = -1;
139 }
static CfgBool cfg_Hunters_Distribute("HUNTERS_DISTRIBUTE", CFG_CUSTOM, false)
Should we enter hunter distribution mode?
bool value(void)
Definition: configurator.h:135
int m_HuntingSeasonEnd
End of the overall hunting season.
Definition: Hunters_all.h:392
int m_HuntingSeasonStart
Start of the overall hunting season.
Definition: Hunters_all.h:390
void DistributeHunters(void)
Distributes hunters to hunting locations (farms).
Definition: Hunters_all.cpp:151
void Init(void)
Create the initial hunter population and initializes any output options.
Definition: Hunters_all.cpp:837
void SetHuntingSeason()
This returns the number of geese which are legal quarry on the polygon the day before.
Definition: Hunters_all.cpp:1498
const char * m_ListNames[32]
Definition: PopulationManager.h:537
unsigned BeforeStepActions[12]
Definition: PopulationManager.h:542
Population_Manager(Landscape *L)
Definition: PopulationManager.cpp:221
unsigned m_ListNameLength
Definition: PopulationManager.h:538
vector< TListOfAnimals > TheArray
Definition: PopulationManager.h:534

References Population_Manager::BeforeStepActions, cfg_Hunters_Distribute, DistributeHunters(), Init(), m_HuntingSeasonEnd, m_HuntingSeasonStart, Population_Manager::m_ListNameLength, Population_Manager::m_ListNames, SetHuntingSeason(), Population_Manager::TheArray, and CfgBool::value().

◆ ~Hunter_Population_Manager()

Hunter_Population_Manager::~Hunter_Population_Manager ( void  )
virtual

Hunter population manager destructor.

142 {
143  // close down output
145  {
146  m_HuntingBagRecord->close();
147  delete m_HuntingBagRecord;
148  }
149 }
static CfgBool cfg_Hunters_RecordBag("HUNTERS_RECORDBAG", CFG_CUSTOM, false)
Should we record the birds shot?
ofstream * m_HuntingBagRecord
Output file for hunting bag record.
Definition: Hunters_all.h:388

References cfg_Hunters_RecordBag, m_HuntingBagRecord, and CfgBool::value().

Member Function Documentation

◆ AddHunterHunting()

bool Hunter_Population_Manager::AddHunterHunting ( int  a_polyref,
Hunter a_hunter 
)

Adds a hunter hunting, returns true if that hunter is the leader otherwise false.

The field that a hunter is hunting is referenced by a_polyref. First we need to check whether this location already exists. NB this list is emptied every day, so only contains locations where hunters have been or are allocated today.

If the location is found, then the hunter is not a leader and we need to tell them that (returns false)

If the polyref does not already exist the location was not found, it must be new, so we need to add it to the list and tell the hunter he is a leader

1478  {
1483  for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
1484  if (m_ActiveHuntingLocationsPolyrefs[ i ] == a_polyref) {
1485  m_ActiveHuntingLocationsHunters[ i ]->push_back( a_hunter );
1487  return false;
1488  }
1489  }
1491  HunterList* p_newhunterlist = new HunterList;
1492  p_newhunterlist->push_back( a_hunter );
1493  m_ActiveHuntingLocationsHunters.push_back( p_newhunterlist );
1494  m_ActiveHuntingLocationsPolyrefs.push_back( a_polyref );
1495  return true;
1496 }
vector< int > m_ActiveHuntingLocationsPolyrefs
Lists of polygon reference numbers for all active hunting locations (updated daily)
Definition: Hunters_all.h:373
vector< HunterList * > m_ActiveHuntingLocationsHunters
Lists of hunters at all active hunting locations (updated daily)
Definition: Hunters_all.h:371
vector< Hunter * > HunterList
Definition: farm.h:211

References m_ActiveHuntingLocationsHunters, and m_ActiveHuntingLocationsPolyrefs.

Referenced by GooseHunter::st_OutHunting().

◆ CheckDensity()

bool Hunter_Population_Manager::CheckDensity ( int  a_ref,
vector< int > *  a_illegalfarms,
vector< FarmOccupcancyData > *  a_FarmOccupancy 
)

helper method to reduce code size in hunter rules - checks density rules

Parameters
[in]a_refThe farm reference number
[in]a_illegalfarmsThe list of farms with densities exceeding the limit set for this run
[in]a_FarmOccupancyThe list of farms that are occupied and the number of hunters allocated to them
Returns
bool true if the hunter could be allocated, false if not

Area is in m2, so divide by 10000. Hunter density in hunters/ha

Loop through all the farms that are already occupied and figure out if we have this one already

301 {
311  //double area = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmTotalSize( a_ref ) / 10000.0;
314  for (int f = 0; f < a_FarmOccupancy->size(); f++) {
315  // test if we have this one
316  if ((*a_FarmOccupancy)[f].m_FarmRef == a_ref) {
317  double newhunters = (*a_FarmOccupancy)[f].m_no_hunters + 1.0;
318  if ( (newhunters/ area) < cfg_Hunters_MaxDensity.value()) {
319  (*a_FarmOccupancy)[f].m_no_hunters++; // Add ourselves
320  return true; // The farm was OK
321  }
322  else {
323  FManager->AddToIllegalList(a_ref, a_illegalfarms);
324  return false;
325  }
326  }
327  }
328  // If we reach here it must be a new farm
329  // New farm, so is it big enough for one hunter?
330  if (1.0 / area > cfg_Hunters_MaxDensity.value())
331  {
332  // Need to add to the illegal list
333  FManager->AddToIllegalList(a_ref, a_illegalfarms);
334  return false;
335  }
336  else {
338  pt.m_FarmRef = a_ref;
339  pt.m_no_hunters = 1;
340  a_FarmOccupancy->push_back(pt);
341  return true;
342  }
343 }
static CfgFloat cfg_Hunters_MaxDensity("HUNTERS_MAXDENSITY", CFG_CUSTOM, 0.1)
Maximum hunter density per ha.
CfgFloat cfg_goose_MinForageOpenness
double value(void)
Definition: configurator.h:118
The Farm Manager class.
Definition: farm.h:1707
int GetFarmAreaOpenFields(int a_farmref, int a_openness)
Returns the area of fields with openness more than a_openness.
Definition: farm.h:1760
void AddToIllegalList(int a_farm_ref, vector< int > *a_farmlist)
Add to a list if a farm is not already among the illegal list of references.
Definition: farm.cpp:3099
FarmManager * SupplyFarmManagerPtr()
Definition: landscape.h:353
Landscape * m_TheLandscape
Definition: PopulationManager.h:515
Definition: Hunters_all.h:103
int m_no_hunters
Definition: Hunters_all.h:105
int m_FarmRef
Definition: Hunters_all.h:104

References FarmManager::AddToIllegalList(), cfg_goose_MinForageOpenness, cfg_Hunters_MaxDensity, FarmManager::GetFarmAreaOpenFields(), FarmOccupcancyData::m_FarmRef, FarmOccupcancyData::m_no_hunters, Population_Manager::m_TheLandscape, Landscape::SupplyFarmManagerPtr(), and CfgFloat::value().

Referenced by DistributeHuntersByRules(), and RuleSet10Based().

◆ CreateObjects()

void Hunter_Population_Manager::CreateObjects ( int  ob_type,
TAnimal ,
struct_Hunter data,
int  number 
)

Creates hunter objects and assigns them to the population manager lists.

926 {
927  GooseHunter* GHunter = NULL;
928  for (int i=0; i<a_number; i++)
929  {
930  switch (a_ob_type)
931  {
932  case toh_GooseHunter:
933  if (g_PopulationManagerList.GetPopulation(TOP_Goose) == NULL) break; // Don't make goose hunters if we are not running geese
934  GHunter = new GooseHunter(p_data, this);
935  TheArray[a_ob_type].push_back(GHunter);
936  break;
937  default:
938  char ob[ 255 ];
939  sprintf( ob, "%d", (int) a_ob_type);
940  m_TheLandscape->Warn("Goose_Population_Manager::CreateObjects() unknown object type - ", ob);
941  exit(1);
942  break;
943  }
944  }
945 }
PopulationManagerList g_PopulationManagerList
Definition: ALMaSS_CmdLine.cpp:136
@ toh_GooseHunter
Definition: Hunters_all.h:47
@ TOP_Goose
Definition: PopulationManager.h:66
The class for goose hunters encompsassing all their specific behaviours.
Definition: Hunters_all.h:269
void Warn(std::string a_msg1, std::string a_msg2)
Definition: landscape.h:1579
Population_Manager * GetPopulation(TTypesOfPopulation a_pt)
Definition: PopulationManager.h:673

References g_PopulationManagerList, PopulationManagerList::GetPopulation(), Population_Manager::m_TheLandscape, Population_Manager::TheArray, toh_GooseHunter, TOP_Goose, and Landscape::Warn().

Referenced by Init().

◆ DistributeHunters()

void Hunter_Population_Manager::DistributeHunters ( void  )

Distributes hunters to hunting locations (farms).

Reads in the hunter home data which consists of a hunter reference and home x,y coordinates only. Hunter type is by default 0 i.e. goose hunter (to be changed when we have more hunter base types)

We now need to add the number of hunting locations to each hunter. This is done by the method GetNoHuntLocs() which returns the number of locations. We use this to resize the storage for the number of locations.

152 {
153 // FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
156  ifstream huntercoords("./HunterHomeLocations.txt", ios::in);
157  if (!huntercoords.is_open()) {
158  m_TheLandscape->Warn( "Hunter_Population_Manager::DistributeHunters()", "HunterHomeLocations.txt missing" );
159  exit( 1 );
160  }
161  int no_hunters;
162  huntercoords >> no_hunters;
163  vector<HunterInfo>* OurHunters = new vector<HunterInfo>;
164  OurHunters->resize( no_hunters );
165  for (int i = 0; i < no_hunters; i++)
166  {
167  huntercoords >> (*OurHunters)[ i ].refID >> (*OurHunters)[ i ].homeX >> (*OurHunters)[ i ].homeY;
172  (*OurHunters)[ i ].FarmHuntRef.resize( GetNoHuntLocs() );
173  for (int hl = 0; hl<(*OurHunters)[i].FarmHuntRef.size(); hl++) (*OurHunters)[i].FarmHuntRef[hl] = -1;
174  //(*OurHunters)[ i ].CheckedFarms.resize( FManager->GetNoFarms() );
175  }
176  huntercoords.close();
177  // Do the distribution
179  // Now save the results
180  SaveDistributedHunters(OurHunters, no_hunters);
181  SaveFarmHunters(OurHunters, no_hunters);
182  g_msg->Warn("Normal exit after hunter distribution. No of records written to Hunter_Hunting_Locations.txt was: ", no_hunters);
183  exit(0);
184 }
static CfgInt cfg_Hunters_Distribute_Ruleset("HUNTERS_DISTRIBUTE_RULESET", CFG_CUSTOM, 0)
The rule set to use for distributing hunters.
int value(void)
Definition: configurator.h:98
unsigned GetNoHuntLocs()
Calculates the number of hunting locations based on a distribution.
Definition: Hunters_all.cpp:186
void SaveDistributedHunters(vector< HunterInfo > *a_hunterlist, int a_no_hunters)
Saves the results of the hunter distribution to an output file.
Definition: Hunters_all.cpp:198
void DistributeHuntersByRules(vector< HunterInfo > *a_hunterlist, int a_no_hunters, int a_ruleset)
Implements the rule sets to distributes hunters to hunting locations (farms).
Definition: Hunters_all.cpp:346
void SaveFarmHunters(vector< HunterInfo > *a_hunterlist, int a_no_hunters)
Saves the results of the hunter distribution to an output file by farm.
Definition: Hunters_all.cpp:233
void Warn(MapErrorState a_level, std::string a_msg1, std::string a_msg2)
Definition: maperrormsg.cpp:59
class MapErrorMsg * g_msg
This pointer provides access the to the internal ALMaSS error message system.
Definition: maperrormsg.cpp:41

References cfg_Hunters_Distribute_Ruleset, DistributeHuntersByRules(), g_msg, GetNoHuntLocs(), Population_Manager::m_TheLandscape, SaveDistributedHunters(), SaveFarmHunters(), CfgInt::value(), MapErrorMsg::Warn(), and Landscape::Warn().

Referenced by Hunter_Population_Manager().

◆ DistributeHuntersByRules()

void Hunter_Population_Manager::DistributeHuntersByRules ( vector< HunterInfo > *  a_hunterlist,
int  a_no_hunters,
int  a_ruleset 
)

Implements the rule sets to distributes hunters to hunting locations (farms).

To distribute the hunters to farms we need the farm information. This resides in the FarmManager held by the landscape, so first we need a pointer to that. The Farm Manager has handy routines for use with the farm allocations .

We need to be able to do the following:

  • Pick a random farm (set 0)
  • Pick the closest farm (set 1)
  • Pick a random farm with openness above x (set 2)
  • Pick a random farm but upto a maximum density of hunters (set 3)
  • The closest farm with openness above x (set 4)
  • Pick the closest farm but upto a max hunter density (set 5)
  • Pick a random farm with openness above x but upto a max hunter density (set 6)
  • Pick the closest farm with openness above and upto a maximum density of hunters (set 7)

Rule set 0 is simply random distribution to any farm

Rule set 1 - the closest farm

Rule set 2 - Random with openness above cfg_GooseMinForageOpenness

Rule set 3 - random subject to hunter density restrictions

Rule set 4 - openness above cfg_GooseMinForageOpenness but closest to home

Rule set 5 - Pick the closest farm but upto a max hunter density

Rule set 6 - Pick a random farm with openness above and upto a maximum density of hunters

Rule set 7 - Pick the closest farm with openness above and upto a maximum density of hunters

Rule set 8 - the closest farm but based on probability. Requires a probability function which is a power curve using one parameter.

Rule set 9 - the closest farm with openness above X, but based on probability for closeness. Requires a probability function which is a power curve using one parameter.

Rule set 10 - the closest farm with openness above X, on probability for closeness and on density. Requires a probability function which is a power curve using one parameter.

Rule set 11 - the closest farm with openness above X, on probability for closeness and on a probability of the acceptance being reduced with farm size. Requires a probability function which is a power curve using one parameter for distance and a second for area.

Rule set 12 - the closest farm with openness above X, on probability for closeness and on a probability of the acceptance being reduced with distance from roost. Requires a probability function which is a power curve using one parameter for distance and a second for roost distance.

347 {
365  // Now we distribute the hunters to farms depending on which rule set we are using
366 
367 
368  FManager->CalcCentroids(); // Makes sure that farm centres are calculated
369  if (a_ruleset == 0)
370  {
372  for (int i = 0; i < a_no_hunters; i++)
373  {
374  // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this.
375  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
376  {
377  int theref = -1;
378  do {
379  // The line below actuall does the interesting bit
380  theref = FManager->GetRandomFarmRefnum();
381  } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
382  (*a_hunterlist)[i].FarmHuntRef[h] = theref;
383  }
384  }
385  }
386  else if (a_ruleset == 1)
387  {
389  vector<int>* list = new vector<int>;
390  list->resize(1);
391  (*list)[0] = 0;
392  for (int i = 0; i < a_no_hunters; i++)
393  {
394  // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this.
395  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
396  {
397  // The line below actuall does the interesting bit
398  (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarm((*a_hunterlist)[i], &list[0]);
399  }
400  }
401  }
402  else if (a_ruleset == 2)
403  {
405  for (int i = 0; i < a_no_hunters; i++)
406  {
407  // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this.
408  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
409  {
410  int theref = -1;
411  do {
412  // The line below actually does the interesting bit
413  theref = FManager->FindOpennessFarm((int)cfg_goose_MinForageOpenness.value());
414  } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
415  (*a_hunterlist)[i].FarmHuntRef[h] = theref;
416  }
417  }
418  }
419  else if (a_ruleset == 3)
420  {
422  vector<int>* illegalfarms = new vector<int>;
423  vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
424  for (int i = 0; i < a_no_hunters; i++)
425  {
426  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
427  {
428  bool found1 = false;
429  int theref = -1;
430  // While a farm is not allocated
431  int iteration = 0;
432  while (!found1) {
433  if (++iteration > FManager->GetNoFarms())
434  {
435  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
436  exit(0);
437  }
438  // Choose a new farm ref to test
439  theref = FManager->FindFarmWithRandom(illegalfarms);
440  found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
441 
442  }
443  (*a_hunterlist)[i].FarmHuntRef[h] = theref;
444 #ifdef __DEBUG_DENSITY
445  double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
446  double nohunters = 0;
447  for (int g = 0; g < a_no_hunters; g++)
448  {
449 
450  for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
451  {
452  if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
453  }
454  }
455  if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
456  {
457  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
458  exit(0);
459  }
460  for (int frm = 0; frm < FarmOccupancy->size(); frm++)
461  {
462 
463  nohunters = 0;
464  for (int g = 0; g < a_no_hunters; g++)
465  {
466 
467  for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
468  {
469  if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
470  }
471  }
472  if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
473  {
474  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
475  exit(0);
476  }
477  }
478 #endif
479 
480  }
481  }
482  }
483  else if (a_ruleset == 4)
484  {
486  vector<int>* list = new vector<int>;
487  list->resize(1);
488  (*list)[0] = 0;
489  for (int i = 0; i < a_no_hunters; i++)
490  {
491  for (int f = 0; f < int((*a_hunterlist)[i].FarmHuntRef.size()); f++)
492  {
493  (*a_hunterlist)[i].FarmHuntRef[f] = FManager->FindClosestFarmOpenness((*a_hunterlist)[i], list, (int)cfg_goose_MinForageOpenness.value());
494  }
495  }
496  }
497  else if (a_ruleset == 5) {
499  // First calculate the hunter densities
500  // This depends on the way we want to do this, one way is total farm area, the other is open farm area.
501  // Both ways are listed here.
502  vector<int>* illegalfarms = new vector<int>;
503  vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
504  // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
505  // For each hunter
506  for (int i = 0; i < a_no_hunters; i++) {
507  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
508  {
509  bool found1 = false;
510  // While a farm is not allocated
511  int iteration = 0;
512  int theref = -1;
513  while (!found1)
514  {
515  if (++iteration > FManager->GetNoFarms())
516  {
517  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
518  exit(0);
519  }
520  // Choose a new farm ref to test
521  theref = FManager->FindClosestFarm((*a_hunterlist)[i], illegalfarms);
522  found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
523  }
524  (*a_hunterlist)[i].FarmHuntRef[h] = theref;
525 #ifdef __DEBUG_DENSITY
526  double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
527  double nohunters = 0;
528  for (int g = 0; g < a_no_hunters; g++)
529  {
530 
531  for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
532  {
533  if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
534  }
535  }
536  if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
537  {
538  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
539  exit(0);
540  }
541  for (int frm = 0; frm < FarmOccupancy->size(); frm++)
542  {
543 
544  nohunters = 0;
545  for (int g = 0; g < a_no_hunters; g++)
546  {
547 
548  for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
549  {
550  if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
551  }
552  }
553  if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
554  {
555  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
556  exit(0);
557  }
558  }
559 #endif
560  }
561  }
562  }
563  else if (a_ruleset == 6) {
565  vector<int>* illegalfarms = new vector<int>;
566  vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
567  int TheOpenness = (int)cfg_goose_MinForageOpenness.value();
568  // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
569  // For each hunter
570  for (int i = 0; i < a_no_hunters; i++) {
571  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
572  int Farms = FManager->GetNoFarms();
573  bool found1 = false;
574  int iteration = 0;
575  int theref = -1;
576  do {
577  if (++iteration > Farms) {
578  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
579  exit(0);
580  }
581  // Choose a new farm ref to test
582  do {
583  // The line below actually does the interesting bit
584  theref = FManager->FindFarmWithOpenness(illegalfarms, TheOpenness);
585  if (theref == -1) {
586  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, in openness, rule set ", cfg_Hunters_Distribute_Ruleset.value());
587  exit(0);
588  }
589  if (illegalfarms->size() >= Farms - ((*a_hunterlist)[ i ].FarmHuntRef.size())) {
590  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, all farms illegal, rule set ", cfg_Hunters_Distribute_Ruleset.value());
591  exit(0);
592  }
593  } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
594  found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
595  } while (!found1);
596  (*a_hunterlist)[i].FarmHuntRef[h] = theref;
597 #ifdef __DEBUG_DENSITY
598  double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
599  double nohunters = 0;
600  for (int g = 0; g < a_no_hunters; g++)
601  {
602 
603  for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
604  {
605  if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
606  }
607  }
608  if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
609  {
610  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
611  exit(0);
612  }
613  for (int frm = 0; frm < FarmOccupancy->size(); frm++)
614  {
615 
616  nohunters = 0;
617  for (int g = 0; g < a_no_hunters; g++)
618  {
619 
620  for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
621  {
622  if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
623  }
624  }
625  if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
626  {
627  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
628  exit(0);
629  }
630  }
631 #endif
632  }
633  }
634  delete illegalfarms;
635  }
636  else if (a_ruleset == 7) {
638  // First calculate the hunter densities
639  // This depends on the way we want to do this, one way is total farm area, the other is open farm area.
640  // Both ways are listed here.
641  vector<int>* illegalfarms = new vector<int>;
642  vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
643  // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
644  // For each hunter
645  for (int i = 0; i < a_no_hunters; i++)
646  {
647  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
648  {
649  bool found1 = false;
650  int theref = -1;
651  // While a farm is not allocated
652  int iteration = 0;
653  while (!found1)
654  {
655  if (++iteration > FManager->GetNoFarms())
656  {
657  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
658  exit(0);
659  }
660  // Choose a new farm ref to test
661  theref = FManager->FindClosestFarmOpenness((*a_hunterlist)[i], illegalfarms, (int)cfg_goose_MinForageOpenness.value());
662  found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
663  }
664  (*a_hunterlist)[i].FarmHuntRef[h] = theref;
665 #ifdef __DEBUG_DENSITY
666  double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
667  double nohunters = 0;
668  for (int g = 0; g < a_no_hunters; g++)
669  {
670 
671  for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
672  {
673  if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
674  }
675  }
676  if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
677  {
678  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
679  exit(0);
680  }
681  for (int frm = 0; frm < FarmOccupancy->size(); frm++)
682  {
683 
684  nohunters = 0;
685  for (int g = 0; g < a_no_hunters; g++)
686  {
687 
688  for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
689  {
690  if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
691  }
692  }
693  if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
694  {
695  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
696  exit(0);
697  }
698  }
699 #endif
700  }
701  }
702  }
703  else if (a_ruleset == 8) {
705  vector<int>* list = new vector<int>;
706  list->resize(1);
707  (*list)[0] = 0;
708  for (int i = 0; i < a_no_hunters; i++) {
709  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
710  (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarmOpennessProb((*a_hunterlist)[i], &list[0], -1); // -1 means no openness will be used
711  }
712  }
713  }
714  else if (a_ruleset == 9) {
716  vector<int>* list = new vector<int>;
717  list->resize(1);
718  (*list)[0] = 0;
719  for (int i = 0; i < a_no_hunters; i++) {
720  for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
721  (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarmOpennessProb((*a_hunterlist)[i], &list[0], (int)cfg_goose_MinForageOpenness.value());
722  }
723  }
724  }
725  else if (a_ruleset == 10) {
727  RuleSet10Based( a_no_hunters, NULL, a_hunterlist, NULL, 10 );
728  }
729  else if (a_ruleset == 11) {
732  // Need to read in the areas real areas for the farms
733  vector<int>* farmsizes = new vector<int>;
734  //read the input file
735  ifstream ifile( "FarmTotalSizeData.txt", ios::in );
736  //check if there is an input file
737  if (!ifile.is_open()) {
738  cout << "Cannot open input file " << "FarmTotalSizeData.txt" << endl;
739  char ch;
740  cin >> ch; //so that it doesn't close immediately
741  exit( 1 );
742  }
743  //get the number of farms
744  int noFarms;
745  ifile >> noFarms; // Could do a check here that this is the right number of farms
746  if (noFarms != m_TheLandscape->SupplyNumberOfFarms()) {
747  cout << "Number of farms does not match farm number in ALMaSS " << noFarms << " != " << m_TheLandscape->SupplyNumberOfFarms() << endl;
748  char ch;
749  cin >> ch; //so that it doesn't close immediately
750  exit( 1 );
751  }
752  //read the data and assign values to the farm's variables
753  for (int f = 0; f < noFarms; f++) {
754  int data;
755  ifile >> data; // this is the farm number
756  ifile >> data;
757  farmsizes->push_back( data );
758  }
759  ifile.close();
760  // OK farm size data read in, lets continue
761  RuleSet10Based( a_no_hunters, farmsizes, a_hunterlist, NULL, 11 );
762  delete farmsizes;
763  }
764  else if (a_ruleset == 12) {
768  // Need to read in the areas real areas for the farms
769  vector<APoint>* roostlocs = new vector<APoint>;
770  //read the input file
771  ifstream ifile( "GooseRoosts.txt", ios::in );
772  //check if there is an input file
773  if (!ifile.is_open()) {
774  cout << "Cannot open input file " << "GooseRoosts.txt" << endl;
775  char ch;
776  cin >> ch; //so that it doesn't close immediately
777  exit( 1 );
778  }
779  //get the number of farms
780  int noroosts;
781  ifile >> noroosts; // Could do a check here that this is the right number of farms
782  //read the data and assign values to the roost locs
783  for (int r = 0; r < noroosts; r++) {
784  APoint data;
785  int species;
786  ifile >> species >> data.m_x >> data.m_y;
787  roostlocs->push_back( data );
788  }
789  ifile.close();
790  // OK farm size data read in, lets continue
791  RuleSet10Based( a_no_hunters, NULL, a_hunterlist, roostlocs, 12 );
792  delete roostlocs;
793  }
794  else {
795  g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - Unknown hunter distribution rule set", cfg_Hunters_Distribute_Ruleset.value());
796  exit(0);
797  }
798 }
A simple class defining an x,y coordinate set.
Definition: ALMaSS_Setup.h:53
int m_y
Definition: ALMaSS_Setup.h:56
int m_x
Definition: ALMaSS_Setup.h:55
int FindClosestFarmOpennessProb(HunterInfo a_hinfo, vector< int > *a_farmlist, int a_openness)
Finds the closest farm to this co-ordinate with openness more than a value but uses a probability dis...
Definition: farm.cpp:3182
int GetNoFarms()
Definition: farm.h:1900
int FindClosestFarmOpenness(HunterInfo a_hinfo, vector< int > *a_farmlist, int a_openness)
Finds the closest farm to this co-ordinate but uses a probability distribtution for acceptance.
Definition: farm.cpp:3155
int FindFarmWithOpenness(vector< int > *a_farmlist, int a_openness)
Finds a farm openness more than a value not on the list.
Definition: farm.cpp:3370
void CalcCentroids()
calculate all farm centroids
Definition: farm.h:1783
int FindClosestFarm(HunterInfo a_hinfo, vector< int > *a_farmlist)
Finds the closest farm to this co-ordinate.
Definition: farm.cpp:3126
int FindOpennessFarm(int a_openness)
Finds a random farm with at least one field with openness above a_openness.
Definition: farm.cpp:3387
bool IsDuplicateRef(int a_ref, HunterInfo *a_hinfo)
Checks if we already have this ref.
Definition: farm.cpp:3116
int GetFarmTotalSize(int a_farmref)
Returns the total farm area from the farm ref num.
Definition: farm.h:1728
int GetRandomFarmRefnum()
Returns a random farm reference number.
Definition: farm.h:1781
int FindFarmWithRandom(vector< int > *a_farmlist)
Finds a farm openness more than a value not on the list.
Definition: farm.cpp:3353
bool CheckDensity(int a_ref, vector< int > *a_illegalfarms, vector< FarmOccupcancyData > *a_FarmOccupancy)
helper method to reduce code size in hunter rules - checks density rules
Definition: Hunters_all.cpp:300
void RuleSet10Based(int a_no_hunters, vector< int > *a_farmsizes, vector< HunterInfo > *a_hunterlist, vector< APoint > *a_roostlocs, int a_ruleset)
Used to implement rule sets based on rule set 10.
Definition: Hunters_all.cpp:800
int SupplyNumberOfFarms()
Definition: landscape.h:1148

References FarmManager::CalcCentroids(), cfg_goose_MinForageOpenness, cfg_Hunters_Distribute_Ruleset, cfg_Hunters_MaxDensity, CheckDensity(), FarmManager::FindClosestFarm(), FarmManager::FindClosestFarmOpenness(), FarmManager::FindClosestFarmOpennessProb(), FarmManager::FindFarmWithOpenness(), FarmManager::FindFarmWithRandom(), FarmManager::FindOpennessFarm(), g_msg, FarmManager::GetFarmTotalSize(), FarmManager::GetNoFarms(), FarmManager::GetRandomFarmRefnum(), FarmManager::IsDuplicateRef(), Population_Manager::m_TheLandscape, APoint::m_x, APoint::m_y, RuleSet10Based(), Landscape::SupplyFarmManagerPtr(), Landscape::SupplyNumberOfFarms(), CfgInt::value(), CfgFloat::value(), and MapErrorMsg::Warn().

Referenced by DistributeHunters().

◆ DoAfter()

virtual void Hunter_Population_Manager::DoAfter ( )
inlineprotectedvirtual

Available for hunter management - not used currently.

Reimplemented from Population_Manager.

402 {}

◆ DoBefore()

virtual void Hunter_Population_Manager::DoBefore ( void  )
inlineprotectedvirtual

Available for hunter management - not used currently.

Reimplemented from Population_Manager.

400 {}

◆ DoFirst()

void Hunter_Population_Manager::DoFirst ( void  )
protectedvirtual

Does general daily tasks e.g. reset time of day, reset bag lists if start of year etc..

Reimplemented from Population_Manager.

948 {
949  int today = m_TheLandscape->SupplyDayInYear();
950  if (m_daytime == 0)
951  {
952  // Start of day so do some housekeeping.
953  // Reset all clocks
954  for (unsigned i=0; i<m_ListNameLength; i++)
955  {
956  int sz = (int) TheArray[i].size();
957  for (int j=0; j<sz; j++)
958  {
959  GooseHunter* h = (GooseHunter*) TheArray[i][j];
960  h->ResetClock();
961  h->OnMorning();
962  if (h->IsOutHunting()) {
963  g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter out hunting at midnight at ref ", h->GetHuntField());
964  g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter clock is ", h->GetClock());
965  g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter is leader ", h->IsLeader());
966  g_msg->Warn("Day in year is: ", m_TheLandscape->SupplyDayInYear());
967  g_msg->Warn("Year is: ", m_TheLandscape->SupplyYearNumber());
968  exit(0);
969  }
970  }
971  }
972  // Clear all active hunting location information
973  for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
975  }
978  // If end of season, reset bags etc.
979  // Here we only need to ask the first hunter in each list, the answer is the same for the rest
980  for (unsigned i = 0; i < m_ListNameLength; i++) {
981  if ((int)TheArray[ i ].size() > 0) {
982  Hunter* h = (Hunter*)TheArray[ i ][ 0 ];
983  if (h->IsSeasonEnd( today ) && m_SeasonNumber > 0) {
984  ofstream ofile( "HuntingOpportunities.txt", ios::app | ios::out);
985  int year = m_TheLandscape->SupplyYearNumber()-1; // This makes it zero based and cuts out the hidden year.
986  int sz = (int)TheArray[ i ].size();
987  for (int j = 0; j < sz; j++) {
988  h = (Hunter*)TheArray[ i ][ j ];
989  ofile << year << '\t';
990  h->SaveMyData( &ofile );
991  h->ResetSeasonData();
992  }
993  ofile.close();
994  }
995  }
996  }
997  }
998  m_daytime = ( m_daytime + 10 ) % 1440; // We have 10 minutes timesteps
999  if (today == 183 && m_daytime == 1430) m_SeasonNumber++;
1000 }
bool IsLeader()
Returns the leader flag.
Definition: Hunters_all.h:325
unsigned m_daytime
Used to follow the time of day in 10 minute steps.
Definition: Hunters_all.h:386
The base class for hunters encompsassing all their general behaviours.
Definition: Hunters_all.h:121
virtual bool IsSeasonEnd(int)
Is it the end of the hunting season? - MUST be overridden in descendent class.
Definition: Hunters_all.h:246
int GetHuntField()
Get the polygon reference number to our current hunting field (which is at a hunting location)
Definition: Hunters_all.h:234
virtual void SaveMyData(ofstream *)
Each hunter needs to save different kinds of data, so we use a polymorphic method for this.
Definition: Hunters_all.h:254
void ResetSeasonData()
Sets the bag and hunting counters to zero.
Definition: Hunters_all.h:218
int GetClock()
Supplies the clock time.
Definition: Hunters_all.h:210
bool IsOutHunting()
A debug function, but may be useful in other contexts. Returns true of currently out hunting.
Definition: Hunters_all.h:223
void ResetClock()
Sets the clock back to zero.
Definition: Hunters_all.h:214
void OnMorning()
Optimism in the morning, perhaps we should hunt?
Definition: Hunters_all.h:228
int SupplyYearNumber(void)
Definition: landscape.h:1616
int SupplyDayInYear(void)
Definition: landscape.h:1596
int m_SeasonNumber
Holds the season number. Used when running goose and hunter sims.
Definition: PopulationManager.h:544

References g_msg, Hunter::GetClock(), Hunter::GetHuntField(), GooseHunter::IsLeader(), Hunter::IsOutHunting(), Hunter::IsSeasonEnd(), m_ActiveHuntingLocationsHunters, m_ActiveHuntingLocationsPolyrefs, m_daytime, Population_Manager::m_ListNameLength, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Hunter::OnMorning(), Hunter::ResetClock(), Hunter::ResetSeasonData(), Hunter::SaveMyData(), Landscape::SupplyDayInYear(), Landscape::SupplyYearNumber(), Population_Manager::TheArray, and MapErrorMsg::Warn().

◆ DoLast()

virtual void Hunter_Population_Manager::DoLast ( void  )
inlineprotectedvirtual

Available for hunter management - not used currently.

Reimplemented from Population_Manager.

404 {}

◆ GetHunterHome()

APoint Hunter_Population_Manager::GetHunterHome ( int  a_index,
int  a_list 
)

Returns the hunter home location.

1017 {
1018  return dynamic_cast<Hunter*>(TheArray[a_list][a_index])->GetHome();
1019 }

References Population_Manager::TheArray.

◆ GetHunterHuntLoc()

APoint Hunter_Population_Manager::GetHunterHuntLoc ( int  a_index,
int  a_list,
unsigned  a_ref 
)

Returns the hunter hunting location location.

1022 {
1023  return dynamic_cast<Hunter*>(TheArray[a_list][a_index])->GetHuntLoc(a_ref);
1024 }

References Population_Manager::TheArray.

◆ GetHuntingSeasonEnd()

int Hunter_Population_Manager::GetHuntingSeasonEnd ( )
inline

Get the end of the overall hunting season.

381 { return m_HuntingSeasonEnd; }

References m_HuntingSeasonEnd.

Referenced by GooseHunter::GetSeasonLengthLeft(), GooseHunter::InSeason(), and GooseHunter::IsSeasonEnd().

◆ GetHuntingSeasonStart()

int Hunter_Population_Manager::GetHuntingSeasonStart ( )
inline

Get the start of the overall hunting season.

379 { return m_HuntingSeasonStart; }

References m_HuntingSeasonStart.

Referenced by GooseHunter::GetSeasonLengthLeft(), and GooseHunter::InSeason().

◆ GetNoHuntLocs()

unsigned Hunter_Population_Manager::GetNoHuntLocs ( )

Calculates the number of hunting locations based on a distribution.

Calculates the number of hunting locations based on a distribution. Uses probability of one location, two locations or three+

187 {
189  double chance = g_rand_uni();
190  if (chance < cfg_hunterlocONE.value()) return 1;
191  if (chance < cfg_hunterlocTWO.value()) return 2;
192  if (chance < cfg_hunterlocTHREE.value()) return 3;
193  if (chance < cfg_hunterlocFOUR.value()) return 4;
194  return 5;
195 
196 }
static CfgFloat cfg_hunterlocTWO("HUNTERS_HUNTERLOCPROB_TWO", CFG_CUSTOM, 0.616)
The cumulative probability of hunters having up to 2 hunter locations.
boost::variate_generator< base_generator_type &, boost::uniform_real<> > g_rand_uni
static CfgFloat cfg_hunterlocFOUR("HUNTERS_HUNTERLOCPROB_FOUR", CFG_CUSTOM, 0.854)
The cumulative probability of hunters having up to 4 hunter locations.
static CfgFloat cfg_hunterlocTHREE("HUNTERS_HUNTERLOCPROB_THREE", CFG_CUSTOM, 0.806)
The cumulative probability of hunters having up to 3 hunter locations.
static CfgFloat cfg_hunterlocONE("HUNTERS_HUNTERLOCPROB_ONE", CFG_CUSTOM, 0.297)
The probability of hunters having one hunter location.

References cfg_hunterlocFOUR, cfg_hunterlocONE, cfg_hunterlocTHREE, cfg_hunterlocTWO, g_rand_uni, and CfgFloat::value().

Referenced by DistributeHunters().

◆ HunterLeaderMessage()

void Hunter_Population_Manager::HunterLeaderMessage ( TypeOfHunterLeaderMessage  a_signal,
int  a_polyref 
)

A message system to rely messages from the leader hunter to others in his team.

This is used to relay a message from a leader hunter to any other hunters in a field at the same time as the leader. The leader passes the polygon reference number which is used to find the list of hunters. They are then each called passing them an event specified by a_signal (currently there is only two types of message, but this can be expanded).

1028 {
1034  for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
1035  if (a_polyref == m_ActiveHuntingLocationsPolyrefs[i])
1036  {
1037  for (int h = 1; h < m_ActiveHuntingLocationsHunters[i]->size(); h++)
1038  {
1039  switch (a_signal)
1040  {
1041  case hlm_shoot:
1042  (*m_ActiveHuntingLocationsHunters[i])[h]->OnShoot();
1043  break;
1044  case hlm_gohome:
1045  (*m_ActiveHuntingLocationsHunters[i])[h]->OnGoHome();
1046  break;
1047  default:
1048  g_msg->Warn("Hunter_Population_Manager::HunterLeaderMessage unknown leader message: ", a_signal);
1049  exit(0);
1050  }
1051  }
1052  return;
1053  }
1054  }
1055  g_msg->Warn("Hunter_Population_Manager::HunterLeaderMessage polyref does not match any of the active polygons in list: ", a_polyref);
1056  exit(0);
1057 }
@ hlm_gohome
Definition: Hunters_all.h:71
@ hlm_shoot
Definition: Hunters_all.h:70

References g_msg, hlm_gohome, hlm_shoot, m_ActiveHuntingLocationsHunters, m_ActiveHuntingLocationsPolyrefs, and MapErrorMsg::Warn().

Referenced by GooseHunter::st_OutHunting().

◆ Init()

void Hunter_Population_Manager::Init ( void  )

Create the initial hunter population and initializes any output options.

Here we need to create the initial hunter population with each individual with its own hunting pattern in terms of timing, location, and intensity/efficiency. Information on hunters is specified in the Hunter_Hunting_Locations.txt file.

One of the challenges is to ensure that we have a matching prey population for each hunter. This is achieved by two structures, the first being a variable in each Population_Manager that states its type (m_population_type) and its associated enum TTypesOfPopulation. The second is a globally visible structure holding a list of any active population managers.

This method also initializes any output options.

838 {
850  int no_hunters;
851  struct_Hunter sh;
852  sh.m_L = m_TheLandscape;
853  ifstream hunterinifile("./Hunter_Hunting_Locations.txt", ios::in);
854  if (!hunterinifile.is_open()) {
855  m_TheLandscape->Warn( "Hunter_Population_Manager::Init", "Hunter_Hunting_Locations.txt missing" );
856  exit( 1 );
857  }
858  hunterinifile >> no_hunters;
859  // Now we skip the header line:
860  string line;
861  for (int i = 0; i < 19; i++) hunterinifile >> line;
862  if (line != "FarmRef10") {
863  m_TheLandscape->Warn( "Hunter_Population_Manager::Init", "Header line missing from Hunter_Hunting_Locations.txt" );
864  exit( 1 );
865  }
866  /*
867  * Reads the hunter data line by hunter line.\n
868  * Each hunter entry is of the following format:\n
869  * - Hunter type (0 = Goose Hunter) (int)
870  * - x/y home location (int)
871  * - Hunting day limit, ie how many days the hunter will go out (int)
872  * - Active hunting days of the week, 1 = everyday, 0 weekends only (int)
873  * - Efficiency (% hits) when geese are present (double)
874  * - Daily chance of checking for geese (prob 0.0-1.0) (double)
875  * - Number of hunting locations (int)
876  * - Farm reference numbers where they hunt (up to 10).
877  *
878  */
879  for (int h = 0; h < no_hunters; h++)
880  {
881  int no_huntlocs;
882  hunterinifile >> sh.m_ref >> sh.m_HType >> sh.m_huntingdayslimit >> sh.m_weekend >> sh.m_goosecountchance >> sh.m_efficiency >> sh.m_home.m_x >> sh.m_home.m_y >> no_huntlocs;
883  // resize our vectors
884  // TODO one day - create another struct to make this a single vector - just to make the code a little more tidy
885  sh.m_farms.resize(no_huntlocs);
886  sh.m_huntlocrefs.resize(no_huntlocs);
887  sh.m_huntlocs.resize(no_huntlocs);
888  for (int i = 0; i < no_huntlocs; i++)
889  {
890  hunterinifile >> sh.m_huntlocrefs[i];
892  sh.m_huntlocs[ i ].m_x = fp.m_x;
893  sh.m_huntlocs[ i ].m_y = fp.m_y;
894  // Need to get the farm* from farmref
896  }
897  for (int i = 0; i < 10-no_huntlocs; i++)
898  {
899  hunterinifile >> line; // Skip the NA's
900  }
902  else
903  {
904  g_msg->Warn("Hunter_Population_Manager::Init unknown hunter type: ", sh.m_HType);
905  exit(0);
906  }
907  CreateObjects( sh.m_HType, NULL, &sh, 1 );
908  }
909  hunterinifile.close();
910 
911  m_daytime = 0; // Make sure we start the simulation at dawn (as the geese do).
912  // Initialise output
914  {
915  m_HuntingBagRecord = new ofstream("HuntingBagRecord.txt", ios::out);
916  (*m_HuntingBagRecord) << "Year" << '\t' << "Day" << '\t' << "Hour" << '\t' << "Minute" << '\t' << "Season" << '\t' <<
917  "HunterRef" << '\t' << "PolygonRef" << '\t' << "x-coord" << '\t' << "y-coord" << '\t' << "GameType" << endl;
918  }
919  ofstream ofile("HuntingOpportunities.txt", ios::out);
920  ofile << "Year" << '\t' << "HunterRef" << '\t' << "HuntingDays" << '\t' << "TotalBag" << '\t' << "NumberOfShots" << '\t' <<
921  "GameType0" << '\t' << "GameType1" << '\t' << "GameType2" << '\t' << "GameType3" << '\t' << "GameType4" << '\t' << "GameType5" << endl;
922  ofile.close();
923 }
APoint GetFarmCentroid(int a_farmref)
Gets the farm centroid as an APoint.
Definition: farm.h:1809
Farm * GetFarmPtr(int a_owner)
Returns the pointer to a farm with a specific number.
Definition: farm.h:1766
void CreateObjects(int ob_type, TAnimal *, struct_Hunter *data, int number)
Creates hunter objects and assigns them to the population manager lists.
Definition: Hunters_all.cpp:925
Used for creation of a new hunter object.
Definition: Hunters_all.h:80
double m_goosecountchance
Definition: Hunters_all.h:93
double m_efficiency
Definition: Hunters_all.h:92
int m_HType
Definition: Hunters_all.h:83
int m_ref
Definition: Hunters_all.h:82
int m_huntingdayslimit
Definition: Hunters_all.h:90
vector< int > m_huntlocrefs
Definition: Hunters_all.h:85
Landscape * m_L
Definition: Hunters_all.h:94
vector< APoint > m_huntlocs
Definition: Hunters_all.h:86
Population_Manager * m_preyPM
Definition: Hunters_all.h:95
APoint m_home
Definition: Hunters_all.h:84
int m_weekend
Definition: Hunters_all.h:91
vector< Farm * > m_farms
Definition: Hunters_all.h:89

References cfg_Hunters_RecordBag, CreateObjects(), g_msg, g_PopulationManagerList, FarmManager::GetFarmCentroid(), FarmManager::GetFarmPtr(), PopulationManagerList::GetPopulation(), m_daytime, struct_Hunter::m_efficiency, struct_Hunter::m_farms, struct_Hunter::m_goosecountchance, struct_Hunter::m_home, struct_Hunter::m_HType, m_HuntingBagRecord, struct_Hunter::m_huntingdayslimit, struct_Hunter::m_huntlocrefs, struct_Hunter::m_huntlocs, struct_Hunter::m_L, struct_Hunter::m_preyPM, struct_Hunter::m_ref, Population_Manager::m_TheLandscape, struct_Hunter::m_weekend, APoint::m_x, APoint::m_y, Landscape::SupplyFarmManagerPtr(), toh_GooseHunter, TOP_Goose, CfgBool::value(), MapErrorMsg::Warn(), and Landscape::Warn().

Referenced by Hunter_Population_Manager().

◆ IsPolyrefOnActiveList()

bool Hunter_Population_Manager::IsPolyrefOnActiveList ( int  a_polyref)

Debugging check method.

1060 {
1061  bool found = false;
1062  for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
1063  if (a_polyref == m_ActiveHuntingLocationsPolyrefs[ i ]) {
1064  found = true;
1065  break;
1066  }
1067  }
1068  return found;
1069 }

References m_ActiveHuntingLocationsPolyrefs.

◆ RecordHuntingSuccess()

void Hunter_Population_Manager::RecordHuntingSuccess ( int  poly,
int  birds,
int  a_hunter 
)

Hunting bag output.

This method stores information about the birds that have been shot. It is essential that the hunting bag record file is open when this is called - there is no checking. This is controlled by a configuration variable cfg_Hunters_RecordBag

1003 {
1008  APoint pt = m_TheLandscape->SupplyCentroid(a_poly);
1009  (*m_HuntingBagRecord) << m_TheLandscape->SupplyYear() << '\t' << m_TheLandscape->SupplyDayInYear() << '\t' << g_date->GetHour() << '\t' <<
1010  g_date->GetMinute() << '\t' << GetSeasonNumber() << '\t' << a_hunter << '\t' << a_poly << '\t' << pt.m_x << '\t' << pt.m_y << '\t' << a_birds << endl;
1011 
1012 
1013 }
class Calendar * g_date
Definition: calendar.cpp:38
int GetHour(void)
Definition: calendar.h:71
int GetMinute(void)
Definition: calendar.h:70
APoint SupplyCentroid(int a_polyref)
Definition: Landscape.cpp:766
int SupplyYear(void)
Definition: landscape.h:1611
int GetSeasonNumber()
Get the season number.
Definition: PopulationManager.h:578

References g_date, Calendar::GetHour(), Calendar::GetMinute(), Population_Manager::GetSeasonNumber(), Population_Manager::m_TheLandscape, APoint::m_x, APoint::m_y, Landscape::SupplyCentroid(), Landscape::SupplyDayInYear(), and Landscape::SupplyYear().

Referenced by GooseHunter::OnShotABird().

◆ RuleSet10Based()

void Hunter_Population_Manager::RuleSet10Based ( int  a_no_hunters,
vector< int > *  a_farmsizes,
vector< HunterInfo > *  a_hunterlist,
vector< APoint > *  a_roostlocs,
int  a_ruleset 
)

Used to implement rule sets based on rule set 10.

800  {
802  vector<int>* illegalfarms = new vector<int>;
803  vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
804  for (int i = 0; i < a_no_hunters; i++) {
805  for (int h = 0; h < int( (*a_hunterlist)[ i ].FarmHuntRef.size() ); h++) {
806  bool found1 = false;
807  int theref = -1;
808  // While a farm is not allocated
809  int iteration = 0;
810  while (!found1) {
811  if (++iteration > FManager->GetNoFarms()) {
812  g_msg->Warn( "Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value() );
813  exit( 0 );
814  }
815  // Choose a new farm ref to test
816  if (a_ruleset == 10) {
817  theref = FManager->FindClosestFarmOpennessProb( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value() );
818  found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
819  }
820  else if (a_ruleset == 11) {
821  // Choose a new farm ref to test
822  theref = FManager->FindClosestFarmOpennessProbSmallIsBest( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value(), a_farmsizes );
823  found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
824  }
825  else if (a_ruleset == 12) {
826  // Choose a new farm ref to test
827  theref = FManager->FindClosestFarmOpennessProbNearRoostIsBest( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value(), a_roostlocs );
828  found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
829  }
830  }
831  (*a_hunterlist)[ i ].FarmHuntRef[ h ] = theref;
832  }
833  }
834  delete illegalfarms;
835 }
int FindClosestFarmOpennessProbSmallIsBest(HunterInfo a_hinfo, vector< int > *a_farmlist, int a_openness, vector< int > *a_farmsizelist)
Finds the closest farm to this co-ordinate with openness more than a value but uses a probability dis...
Definition: farm.cpp:3233
int FindClosestFarmOpennessProbNearRoostIsBest(HunterInfo a_hinfo, vector< int > *a_farmlist, int a_openness, vector< APoint > *a_farmsizelist)
Finds the closest farm to this co-ordinate with openness more than a value but uses a probability dis...
Definition: farm.cpp:3289

References cfg_goose_MinForageOpenness, cfg_Hunters_Distribute_Ruleset, CheckDensity(), FarmManager::FindClosestFarmOpennessProb(), FarmManager::FindClosestFarmOpennessProbNearRoostIsBest(), FarmManager::FindClosestFarmOpennessProbSmallIsBest(), g_msg, FarmManager::GetNoFarms(), Population_Manager::m_TheLandscape, Landscape::SupplyFarmManagerPtr(), CfgInt::value(), CfgFloat::value(), and MapErrorMsg::Warn().

Referenced by DistributeHuntersByRules().

◆ SaveDistributedHunters()

void Hunter_Population_Manager::SaveDistributedHunters ( vector< HunterInfo > *  a_hunterlist,
int  a_no_hunters 
)

Saves the results of the hunter distribution to an output file.

199 {
200  ofstream huntlocs("./Hunter_Hunting_Locations.txt", ios::out);
201  huntlocs << a_no_hunters << endl;
202  huntlocs << "HunterID" << '\t' << "HunterType" << '\t' << "HuntingDays" << '\t' << "WeekdayHunterChance" << '\t' << "GooseLookChance" << '\t' << "Efficiency" << '\t';
203  huntlocs << "HomeX" << '\t' << "HomeY" << '\t';
204  huntlocs << "NoFarmrefs" << '\t' << "FarmRef1" << '\t' << "FarmRef2" << '\t' << "FarmRef3" << '\t' << "FarmRef4" << '\t' << "FarmRef5" << '\t' << "FarmRef6" << '\t' << "FarmRef7" << '\t' << "FarmRef8" << '\t' << "FarmRef9" << '\t' << "FarmRef10" << endl;
205 
206  //<< '\t' << "FarmCentroidX" << '\t' << "FarmCentroidY" << '\t' << "FarmTotalSize" << '\t' << "FarmArableSize" << '\t' << "FarmType" << '\t' << "NoFields" << '\t' << "NoOpenFields" << '\t' << "ValidFarmX" << '\t' << "ValidFarmY" << endl;
207  /*FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();*/
208  for (int i = 0; i < a_no_hunters; i++)
209  {
210  int nolocs = int((*a_hunterlist)[i].FarmHuntRef.size());
211  huntlocs << (*a_hunterlist)[ i ].refID << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t';
212  huntlocs << (*a_hunterlist)[ i ].homeX << '\t' << (*a_hunterlist)[ i ].homeY << '\t' << nolocs;
213  for (int j = 0; j < nolocs; j++)
214  {
215  int ref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
216  /*
217  APoint pt = FManager->GetFarmCentroid(ref);
218  int FarmASize = FManager->GetFarmArableSize(ref);
219  int FarmTSize = FManager->GetFarmTotalSize(ref);
220  int FarmType = FManager->GetFarmType(ref);
221  int OpenFields = FManager->GetFarmNoOpenFields(ref, (int)cfg_GooseMinForageOpenness.value());
222  int NoFields = FManager->GetFarmNoFields(ref);
223  APoint valid = FManager->GetFarmValidCoords(ref);*/
224  huntlocs << '\t' << ref;
225  }
226  for (int j = 10; j > nolocs; j--) huntlocs << '\t' << "NA";
227  huntlocs << endl;
228  }
229  huntlocs.close();
230 }

Referenced by DistributeHunters().

◆ SaveFarmHunters()

void Hunter_Population_Manager::SaveFarmHunters ( vector< HunterInfo > *  a_hunterlist,
int  a_no_hunters 
)

Saves the results of the hunter distribution to an output file by farm.

233  {
235  ofstream huntlocs("./Hunter_Hunting_Locations_Farms.txt", ios::out);
236  huntlocs << "FarmRef" << '\t' << "FarmCentroidX" << '\t' << "FarmCentroidY" << '\t' << "FarmType" << '\t' << "FarmSize" << '\t'
237  << "FarmArableSize" << '\t' << "NoFields" << '\t' << "NoOpenFields" << '\t' <<"AreaOpenFields" << '\t' << "NoHunters" << endl;
238  vector<farminfo*> FarmList;
239  for (int i = 0; i < a_no_hunters; i++)
240  {
241  for (int j = 0; j < (*a_hunterlist)[ i ].FarmHuntRef.size(); j++)
242  {
243  int ref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
244  int found = -1;
245  for (int f = 0; f < (int)FarmList.size(); f++) {
246  if (FarmList[f]->m_farmref == ref) {
247  found = f;
248  break;
249  }
250  }
251  if (found == -1) {
252  farminfo* fi = new farminfo;
253  fi->m_farmcentroid = FManager->GetFarmCentroid( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
254  fi->m_farmvalid = FManager->GetFarmValidCoords( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
255  fi->m_farmarable = FManager->GetFarmArableSize( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
256  fi->m_farmsize = FManager->GetFarmTotalSize( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
257  fi->m_farmtype = FManager->GetFarmType( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
258  fi->m_openfields = FManager->GetFarmNoOpenFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ], (int)cfg_goose_MinForageOpenness.value() );
259  fi->m_areaopenfields = FManager->GetFarmAreaOpenFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ], (int)cfg_goose_MinForageOpenness.value() );
260  fi->m_nofields = FManager->GetFarmNoFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
261  fi->m_farmref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
262  fi->m_NoHunters = 1;
263  FarmList.push_back(fi);
264  }
265  else FarmList[found]->m_NoHunters++;
266  }
267  }
268  // Now we don't want any gaps so check all farms and then check them against our list of hunted farms
269  int nofarms = FManager->GetNoFarms();
270  for (int fa = 0; fa < nofarms; fa++) {
271  int found = -1;
272  Farm* farmp = FManager->GetFarmPtrIndex(fa);
273  int ref = farmp->GetFarmNumber();
274  cout << ref << '\t';
275  for (int hf = 0; hf < FarmList.size( ); hf++)
276  {
277  if (FarmList[hf]->m_farmref == ref) {
278  found = hf;
279  cout << ref << '\t' << found << endl;
280  break;
281  }
282  }
283  if (found == -1) {
284  APoint pt = FManager->GetFarmCentroid( ref );
285  huntlocs << ref << '\t' << pt.m_x << '\t' << pt.m_y << '\t' << FManager->GetFarmType(ref) << '\t' << FManager->GetFarmTotalSize(ref) << '\t'
286  << FManager->GetFarmArableSize(ref) << '\t' << FManager->GetFarmNoFields(ref) << '\t'
287  << FManager->GetFarmNoOpenFields(ref, (int)cfg_goose_MinForageOpenness.value()) << '\t' << FManager->GetFarmAreaOpenFields(ref, (int)cfg_goose_MinForageOpenness.value()) << '\t' << 0 << endl;
288  }
289  else {
290  huntlocs << ref << '\t' << FarmList[found]->m_farmcentroid.m_x << '\t' << FarmList[found]->m_farmcentroid.m_y << '\t' << FarmList[found]->m_farmtype << '\t' << FarmList[found]->m_farmsize << '\t'
291  << FarmList[found]->m_farmarable << '\t' << FarmList[found]->m_nofields << '\t' << FarmList[found]->m_openfields << '\t' << FarmList[found]->m_areaopenfields << '\t' << FarmList[found]->m_NoHunters << endl;
292  }
293 
294  }
295  huntlocs.close();
296 }
The base class for all farm types.
Definition: farm.h:768
int GetFarmNumber(void)
Definition: farm.h:782
int GetFarmNoOpenFields(int a_farmref, int a_openness)
Returns the number of fields with openness more than a_openness.
Definition: farm.h:1754
int GetFarmNoFields(int a_farmref)
Returns the number of fields owned by a from the farm ref num.
Definition: farm.h:1743
TTypesOfFarm GetFarmType(int a_farmref)
Returns the farm type from the farm ref num.
Definition: farm.h:1738
APoint GetFarmValidCoords(int a_farmref)
Returns the number of fields owned by a from the farm ref num.
Definition: farm.h:1748
int GetFarmArableSize(int a_farmref)
Returns the arable area from the farm ref num.
Definition: farm.h:1733
Farm * GetFarmPtrIndex(int a_index)
Returns the pointer to a farm with a specific index.
Definition: farm.h:1777
Used during saving farm/hunter information.
Definition: farm.h:493
int m_farmref
Definition: farm.h:494
int m_farmtype
Definition: farm.h:495
int m_areaopenfields
Definition: farm.h:500
int m_farmarable
Definition: farm.h:497
int m_openfields
Definition: farm.h:499
int m_nofields
Definition: farm.h:498
int m_NoHunters
Definition: farm.h:503
APoint m_farmvalid
Definition: farm.h:502
int m_farmsize
Definition: farm.h:496
APoint m_farmcentroid
Definition: farm.h:501

References cfg_goose_MinForageOpenness, FarmManager::GetFarmArableSize(), FarmManager::GetFarmAreaOpenFields(), FarmManager::GetFarmCentroid(), FarmManager::GetFarmNoFields(), FarmManager::GetFarmNoOpenFields(), Farm::GetFarmNumber(), FarmManager::GetFarmPtrIndex(), FarmManager::GetFarmTotalSize(), FarmManager::GetFarmType(), FarmManager::GetFarmValidCoords(), FarmManager::GetNoFarms(), farminfo::m_areaopenfields, farminfo::m_farmarable, farminfo::m_farmcentroid, farminfo::m_farmref, farminfo::m_farmsize, farminfo::m_farmtype, farminfo::m_farmvalid, farminfo::m_nofields, farminfo::m_NoHunters, farminfo::m_openfields, Population_Manager::m_TheLandscape, APoint::m_x, APoint::m_y, Landscape::SupplyFarmManagerPtr(), and CfgFloat::value().

Referenced by DistributeHunters().

◆ SetHuntingSeason()

void Hunter_Population_Manager::SetHuntingSeason ( )

This returns the number of geese which are legal quarry on the polygon the day before.

The goose hunting season is complicated because it runs over a year boundary (or it can)

1498  {
1502  int start2 = cfg_goose_greylagopenseasonstart.value();
1504  /*Both start and end in the same year*/
1505  if (end1 > start1 && end2 > start2) {
1506  m_HuntingSeasonEnd = end1;
1507  if (m_HuntingSeasonEnd < end2)
1508  {
1509  m_HuntingSeasonEnd = end2;
1510  }
1511  }
1512  /*1 end in the second year*/
1513  if (start1 > end1 && start2 < end2)
1514  {
1515  m_HuntingSeasonEnd = end1;
1516  }
1517  /*2 end in the second year*/
1518  if (start1 < end1 && start2 > end2)
1519  {
1520  m_HuntingSeasonEnd = end2;
1521  }
1522  /*Both end in the second year*/
1523  if (start1 > end1 && start2 > end2)
1524  {
1525  m_HuntingSeasonEnd = end1;
1526  if (m_HuntingSeasonEnd < end2)
1527  {
1528  m_HuntingSeasonEnd = end2;
1529  }
1530  }
1531  if (start1 > start2)
1532  {
1533  m_HuntingSeasonStart = start2;
1534  }
1535  else m_HuntingSeasonStart = start1;
1536  if (m_HuntingSeasonStart < 0)
1537  {
1538  g_msg->Warn("Goose_Population_Manager::SetHuntingSeason() Start of hunting season:", m_HuntingSeasonStart);
1539  exit(1);
1540  }
1541  if (m_HuntingSeasonEnd < 0)
1542  {
1543  g_msg->Warn("Goose_Population_Manager::SetHuntingSeason() End of hunting season:", m_HuntingSeasonEnd);
1544  exit(1);
1545  }
1546 }
CfgInt cfg_goose_greylagopenseasonend
CfgInt cfg_goose_pinkfootopenseasonstart
CfgInt cfg_goose_greylagopenseasonstart
CfgInt cfg_goose_pinkfootopenseasonend

References cfg_goose_greylagopenseasonend, cfg_goose_greylagopenseasonstart, cfg_goose_pinkfootopenseasonend, cfg_goose_pinkfootopenseasonstart, g_msg, m_HuntingSeasonEnd, m_HuntingSeasonStart, CfgInt::value(), and MapErrorMsg::Warn().

Referenced by Hunter_Population_Manager().

◆ StepFinished()

virtual bool Hunter_Population_Manager::StepFinished ( void  )
inlineprotectedvirtual

Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour.

Returns true if and only if all objects have finished the current step

Reimplemented from Population_Manager.

396 { return true; }

Member Data Documentation

◆ m_ActiveHuntingLocationsHunters

vector<HunterList*> Hunter_Population_Manager::m_ActiveHuntingLocationsHunters

Lists of hunters at all active hunting locations (updated daily)

Referenced by AddHunterHunting(), DoFirst(), and HunterLeaderMessage().

◆ m_ActiveHuntingLocationsPolyrefs

vector<int> Hunter_Population_Manager::m_ActiveHuntingLocationsPolyrefs

Lists of polygon reference numbers for all active hunting locations (updated daily)

Referenced by AddHunterHunting(), DoFirst(), HunterLeaderMessage(), and IsPolyrefOnActiveList().

◆ m_daytime

unsigned Hunter_Population_Manager::m_daytime
protected

Used to follow the time of day in 10 minute steps.

Referenced by DoFirst(), and Init().

◆ m_HuntingBagRecord

ofstream* Hunter_Population_Manager::m_HuntingBagRecord
protected

Output file for hunting bag record.

Referenced by Init(), and ~Hunter_Population_Manager().

◆ m_HuntingSeasonEnd

int Hunter_Population_Manager::m_HuntingSeasonEnd
protected

End of the overall hunting season.

Referenced by GetHuntingSeasonEnd(), Hunter_Population_Manager(), and SetHuntingSeason().

◆ m_HuntingSeasonStart

int Hunter_Population_Manager::m_HuntingSeasonStart
protected

Start of the overall hunting season.

Referenced by GetHuntingSeasonStart(), Hunter_Population_Manager(), and SetHuntingSeason().


The documentation for this class was generated from the following files: